from .getPublicData import *
import json
import time


def getNowTime():
    timeFormat = time.localtime()  # 获取当前时间
    year = timeFormat.tm_year
    mon = timeFormat.tm_mon
    day = timeFormat.tm_mday
    return year, monthList[mon - 1], day  # 这里月份获取的是字符串，如果不这么写，只会返回数字


def getUserCreateTime():
    users = getAllUsers()  # 获取数据库中所有用户信息
    date = {}  # 用于存储不同创建时间的用户数量；键是createTime，值是用户数量

    '''
    遍历所有用户，统计每个创建时间的数量
        1.获取createTime的值，如果字典中没有这个创建时间，则会默认返回-1
        2.如果返回的是-1，则说明这是第一次遇到该创建时间，于是将该创建时间赋初值为1
        3.如果返回的不是-1，则说明已经有过这个时间的用户，将该创建时间的用户数量+1
    '''
    for u in users:  # 遍历每一条用户信息
        if date.get(str(u.createTime), -1) == -1:
            date[str(u.createTime)] = 1
        else:
            date[str(u.createTime)] += 1

    '''
    格式化结果
        在这里，我们遍历字典 date 中的所有键值对（k 和 v），其中 k 是创建时间（字符串形式），v 是对应的用户数量。
        每一对 k 和 v 被转化成一个字典 {'name': k, 'value': v}，并添加到 result 列表中。
            name 表示用户的创建时间（字符串形式）。
            value 表示该时间创建的用户数量。
    '''
    result = []
    for k, v in date.items():
        result.append({
            'name': k,
            'value': v
        })
    return result   # 最后返回一个数组，数组中包含多个对象


def getTagData():
    jobs = getAllJobs()
    users = getAllUsers()
    educationsTop = "学历不限"
    salaryTop = 0
    salaryMonthTop = 0
    address = {}
    practice = {}
    for job in jobs:

        if educations[job.educational] < educations[educationsTop]: # 最高学历
            educationsTop = job.educational

        '''
            我们需要使用json.loads()方法将字符串类型解析为python对象
            salary在数据中是一个字符串，字符串的里面又是一个列表
            我们使用json.loads(job.salary)方法将'[5000,8000]'解析为[5000,8000],然后取第二个值，也就是8000
            再去判断当前数组的值是否大于最高薪资
        '''
        if not job.practice:
            salary = json.loads(job.salary)[1]
            if salaryTop < salary:
                salaryTop = salary

        if int(job.salaryMonth) > salaryMonthTop:
            salaryMonthTop = int(job.salaryMonth)
        if address.get(job.address, -1) == -1:  # 地点计数，看哪些地点的岗位最多
            address[job.address] = 1
        else:
            address[job.address] += 1
        if practice.get(job.practice, -1) == -1: # 岗位技术，看正式岗位多还是实习岗多
            practice[job.practice] = 1
        else:
            practice[job.practice] += 1

    '''
        sorted函数：
            iterable：必需，要排序的可迭代对象（如列表、元组、字符串等）。
            key：可选，指定一个函数，用来从每个元素中提取一个用于比较的键。如果省略，默认使用元素本身进行比较。
            reverse：可选，布尔值。True 表示降序排列，False 表示升序排列（默认是升序）。
            
        address：{"武汉":12,"北京":6,"上海":1,"深圳":14,}
        address.items：[("武汉",12),("北京",6),("上海",1),("深圳",14)]
        
        拿 12,6,1,14 出来比较，然后按降序排列，最后传入前三位的值
        [("深圳",14),("武汉",12),("北京",6)]
        
        最后再用addressTop获取每一个元组里面的城市名，并加上逗号

    '''
    addressStr = sorted(address.items(), key=lambda x: x[1], reverse=True)[:3]
    addressTop = ""
    for i in addressStr:
        addressTop += i[0] + ","


    practiceMax = sorted(practice.items(), key=lambda x: x[1], reverse=True)
    # a = "普通岗位" ? practiceMax[0][0] == False : "实习岗位"
    return len(jobs), len(users), educationsTop, salaryTop, salaryMonthTop, addressTop, practiceMax[0][0]


def getUserTop5():
    users = getAllUsers()

    def sort_fn(item):
        '''
        时间格式转换
            先将数据库中的createTime转变为字符串格式
            然后将字符串以%Y-%m-%d的形式转变为时间结构体
                time.struct_time(tm_year=2024, tm_mon=12, tm_mday=5, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=340, tm_isdst=-1)
            最后再将时间结构体转变为时间戳并返回
        '''
        return time.mktime(time.strptime(str(item.createTime), '%Y-%m-%d'))

    '''
        提取前六个创建时间最近的用户，组成一个列表并返回
    '''
    users = list(sorted(users, key=sort_fn, reverse=True))[:6]
    return users


def getAllJobsPBar():
    jobs = getAllJobs()
    tempData = {}
    for job in jobs:
        if tempData.get(str(job.createTime), -1) == -1:
            tempData[str(job.createTime)] = 1
        else:
            tempData[str(job.createTime)] += 1

    def sort_fn(item):
        item = list(item)
        return time.mktime(time.strptime(str(item[0]), '%Y-%m-%d'))
    '''
        按时间从远到近排序
        result=[('2024-12-01', 20), ('2024-12-03', 1657), ('2024-12-20', 4966), ('2024-12-21', 5156)]
    '''
    result = list(sorted(tempData.items(), key=sort_fn, reverse=False))


    def map_fn(item):
        ''''
            计算每一个日期爬取的数据占所有数据的总比例
        '''
        item = list(item)
        item.append(round(item[1] / len(jobs) * 100, 3))
        return item

    '''
    map函数           
        function：一个函数，map 会把这个函数应用到 iterable 中的每个元素。
        iterable：一个或多个可迭代对象（如列表、元组等）。map 会逐个获取 iterable 中的元素，并将它们作为参数传递给 function。
    result = list(map(map_fn, result))
        将result中的每一个元组拿出来，然后传参给map_fn
        map_fn计算完数据占比后，返回一个列表回来
        最后将所有列表组合在一个列表下，然后返回result
    result = [['2024-12-01', 20, 0.17], ['2024-12-03', 1657, 14.044], ['2024-12-20', 4966, 42.088], ['2024-12-21', 5156, 43.699]]
    '''
    result = list(map(map_fn, result))
    return result


def getTableData():
    jobs = getAllJobs()
    for i in jobs:
        '''
        使用 '/'.join() 将列表中的元素连接成一个字符串，元素之间用 '/' 分隔。例如，["开发", "前端"] 会变成 '开发/前端'。
        '''
        i.workTag = '/'.join(json.loads(i.workTag))
        if i.companyTags != "无":
            i.companyTags = '/'.join(json.loads(i.companyTags))
        if i.companyPeople == '[0, 10000]':
            i.companyPeople = '10000人以上'
        else:
            '''
            i.companyPeople = [0,500]
            将数组中的元素转化为字符串并加上'人'
            删除第一个元素的'人'
            最后使用'-'连接两个数组数组元素,变成一个字符串
            '''
            i.companyPeople = json.loads(i.companyPeople)
            i.companyPeople = list(map(lambda x: str(x) + '人', i.companyPeople))
            i.companyPeople[0] = i.companyPeople[0].replace('人','')
            i.companyPeople = '-'.join(i.companyPeople)
        i.salary = json.loads(i.salary)[1]
    return jobs

